package a.j;

import a.e.c;

import java.awt.*;
import java.awt.geom.*;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Map;

public class od
  extends ld
{
  public static final RenderingHints.Key n = new b_();
  public static final Object F = new a_();
  public static final byte G = 0;
  public static final byte H = 1;
  public static final byte I = 2;
  public static final byte J = 3;
  public static final byte K = 4;
  public static final byte L = 5;
  public static final byte M = 6;
  public static final byte N = 7;
  public static final byte O = 8;
  public static final byte P = 9;
  public static final byte Q = 10;
  protected Shape R;
  private byte S;
  private static final double T = 5.0D;
  private static final double U = 1.221730476396031D;
  private static Color V = new Color(179, 166, 145);
  private byte W = 0;
  private byte X = 0;
  private Color Y;
  private static final double Z = 0.7D;
  public static boolean ab;
  
  public od()
  {
    this((byte)0, 0.0D, 0.0D, "");
  }
  
  public od(byte paramByte)
  {
    this(paramByte, 0.0D, 0.0D, "");
  }
  
  public od(byte paramByte, double paramDouble1, double paramDouble2, String paramString)
  {
    super(paramDouble1, paramDouble2, paramString);
    this.Y = V;
    b(paramByte);
  }
  
  public od(ld paramld)
  {
    super(paramld);
    if (!bool)
    {
      this.Y = V;
      if ((paramld instanceof od))
      {
        od localod = (od)paramld;
        b(localod.U());
        this.Y = localod.Y;
        this.X = localod.X;
        if (bool) {
          break label86;
        }
        this.W = localod.W;
        if (!ld.D) {
          return;
        }
      }
    }
    label86:
    b((byte)0);
  }
  
  public ld a(ld paramld)
  {
    return new od(paramld);
  }
  
  public void c(double paramDouble1, double paramDouble2)
  {
    g(paramDouble1 - c() / 2.0D, paramDouble2 - d() / 2.0D);
  }
  
  public void a(double paramDouble1, double paramDouble2)
  {
    g(paramDouble1, paramDouble2);
  }
  
  private void g(double paramDouble1, double paramDouble2)
  {
    boolean bool = ld.E;
    if (!bool) {
      if ((this.R instanceof RectangularShape))
      {
        super.a(paramDouble1, paramDouble2);
        ((RectangularShape)this.R).setFrame(this.y, this.z, this.A, this.B);
      }
    }
    if ((bool) || ((ld.D) && ((bool) || ((this.R instanceof GeneralPath)))))
    {
      ((GeneralPath)this.R).transform(AffineTransform.getTranslateInstance(paramDouble1 - this.y, paramDouble2 - this.z));
      super.a(paramDouble1, paramDouble2);
    }
  }
  
  public void d(double paramDouble1, double paramDouble2)
  {
    g(a() + paramDouble1, b() + paramDouble2);
  }
  
  public void b(double paramDouble1, double paramDouble2)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (!bool2) {
      if (paramDouble1 == this.A)
      {
        if (bool2) {
          break label46;
        }
        if (paramDouble2 == this.B) {
          return;
        }
      }
    }
    label46:
    if (!bool2) {
      if ((this.R instanceof RectangularShape))
      {
        super.b(paramDouble1, paramDouble2);
        ((RectangularShape)this.R).setFrame(this.y, this.z, paramDouble1, paramDouble2);
        if (!bool2) {
          if (!bool1) {
            return;
          }
        }
      }
      else
      {
        if (bool2) {
          break label253;
        }
      }
    }
    if ((this.R instanceof GeneralPath))
    {
      if (!bool2)
      {
        if (this.A != 0.0D)
        {
          if (bool2) {
            break label169;
          }
          if (this.B != 0.0D) {}
        }
        else
        {
          super.b(paramDouble1, paramDouble2);
          if (bool2) {
            break label158;
          }
          b(U());
        }
      }
      else if (!bool1) {
        return;
      }
      label158:
      label169:
      double d1 = this.y + this.A / 2.0D;
      double d2 = this.z + this.B / 2.0D;
      AffineTransform localAffineTransform = AffineTransform.getTranslateInstance(d1, d2);
      localAffineTransform.scale(paramDouble1 / this.A, paramDouble2 / this.B);
      localAffineTransform.translate(-d1, -d2);
      ((GeneralPath)this.R).transform(localAffineTransform);
      if (bool2) {
        break label255;
      }
      super.b(paramDouble1, paramDouble2);
      if (!bool1) {
        return;
      }
    }
    label253:
    label255:
    super.b(paramDouble1, paramDouble2);
  }
  
  private double T()
  {
    return this.A / 2.0D;
  }
  
  public void b(byte paramByte)
  {
    GeneralPath localGeneralPath;
    switch (paramByte)
    {
    case 2: 
      this.R = new Ellipse2D.Double(this.y, this.z, this.A, this.B);
      break;
    case 0: 
    case 6: 
      this.R = new Rectangle2D.Double(this.y, this.z, this.A, this.B);
      break;
    case 1: 
      this.R = new RoundRectangle2D.Double(this.y, this.z, this.A, this.B, 8.0D, 8.0D);
      break;
    case 3: 
      localGeneralPath = new GeneralPath(0, 5);
      localGeneralPath.moveTo((float)(this.y + this.A * 0.1D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A * 0.9D), (float)(this.z + this.B));
      localGeneralPath.lineTo((float)this.y, (float)(this.z + this.B));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
      break;
    case 4: 
      localGeneralPath = new GeneralPath(0, 6);
      localGeneralPath.moveTo((float)this.y, (float)(this.z + this.B / 2.0D));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.1D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A * 0.9D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)(this.z + this.B / 2.0D));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.9D), (float)(this.z + this.B));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.1D), (float)(this.z + this.B));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
      break;
    case 5: 
      localGeneralPath = new GeneralPath(0, 3);
      localGeneralPath.moveTo((float)(this.y + this.A / 2.0D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)(this.z + this.B));
      localGeneralPath.lineTo((float)this.y, (float)(this.z + this.B));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
      break;
    case 7: 
      double d1 = Math.sqrt(2.0D);
      double d2 = this.A / (2.0D + d1);
      double d3 = this.B / (2.0D + d1);
      localGeneralPath = new GeneralPath(0, 8);
      localGeneralPath.moveTo((float)this.y, (float)(this.z + d3));
      localGeneralPath.lineTo((float)(this.y + d2), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A - d2), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)(this.z + d3));
      localGeneralPath.lineTo((float)(this.y + this.A), (float)(this.z + this.B - d3));
      localGeneralPath.lineTo((float)(this.y + this.A - d2), (float)(this.z + this.B));
      localGeneralPath.lineTo((float)(this.y + d2), (float)(this.z + this.B));
      localGeneralPath.lineTo((float)this.y, (float)(this.z + this.B - d3));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
      break;
    case 8: 
      localGeneralPath = new GeneralPath(0, 4);
      localGeneralPath.moveTo((float)this.y, (float)(this.z + this.B * 0.5D));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.5D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)(this.z + this.B * 0.5D));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.5D), (float)(this.z + this.B));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
      break;
    case 9: 
      localGeneralPath = new GeneralPath(0, 4);
      localGeneralPath.moveTo((float)this.y, (float)(this.z + this.B));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.25D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A * 0.75D), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)(this.z + this.B));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
      break;
    case 10: 
      localGeneralPath = new GeneralPath(0, 4);
      localGeneralPath.moveTo((float)this.y, (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A), (float)this.z);
      localGeneralPath.lineTo((float)(this.y + this.A * 0.75D), (float)(this.z + this.B));
      localGeneralPath.lineTo((float)(this.y + this.A * 0.25D), (float)(this.z + this.B));
      localGeneralPath.closePath();
      this.R = localGeneralPath;
    }
    this.S = paramByte;
    R();
  }
  
  public byte U()
  {
    return this.S;
  }
  
  public Color V()
  {
    return this.Y;
  }
  
  public void f(Color paramColor)
  {
    this.Y = paramColor;
  }
  
  public byte W()
  {
    return this.X;
  }
  
  public void c(byte paramByte)
  {
    this.X = paramByte;
  }
  
  public byte X()
  {
    return this.W;
  }
  
  public void d(byte paramByte)
  {
    this.W = paramByte;
  }
  
  public boolean Y()
  {
    boolean bool = ld.E;
    if ((bool) || (this.Y != null)) {
      if (!bool) {
        if (this.W == 0) {
          if (bool) {
            break label38;
          }
        }
      }
    }
    label38:
    return this.X != 0;
  }
  
  void d(Graphics2D paramGraphics2D)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (F.equals(paramGraphics2D.getRenderingHint(n)))
    {
      Color localColor1 = o();
      if (!bool2)
      {
        if (a(this, paramGraphics2D))
        {
          paramGraphics2D.setColor(J());
          paramGraphics2D.fill(this.R);
        }
      }
      else {
        if (!bool1) {
          break label86;
        }
      }
      if (!bool2) {
        if (localColor1 != null)
        {
          paramGraphics2D.setColor(localColor1);
          paramGraphics2D.fill(this.R);
        }
      }
      label86:
      Color localColor2 = q();
      if (!bool2)
      {
        if (localColor2 != null)
        {
          paramGraphics2D.setColor(localColor2);
          paramGraphics2D.draw(this.R);
        }
      }
      else if (!bool1) {}
    }
    else
    {
      super.d(paramGraphics2D);
    }
  }
  
  protected void a(Graphics2D paramGraphics2D)
  {
    boolean bool = ld.E;
    if (!bool) {
      if (a(this, paramGraphics2D)) {
        b(paramGraphics2D);
      }
    }
    if (!bool)
    {
      if (kg.d(paramGraphics2D)) {
        j(paramGraphics2D);
      }
      i(paramGraphics2D);
    }
    if (!bool) {
      if (c(paramGraphics2D, false)) {
        g(paramGraphics2D);
      }
    }
    if (a(paramGraphics2D, false)) {
      f(paramGraphics2D);
    }
    h(paramGraphics2D);
  }
  
  protected void h(Graphics2D paramGraphics2D)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    int i = U();
    Color localColor;
    if (i == 6)
    {
      localColor = o();
      if (!bool2)
      {
        if (localColor == null) {
          return;
        }
        paramGraphics2D.setColor(localColor);
        b(paramGraphics2D, true);
      }
      if (!bool2) {
        if (!bool1) {
          return;
        }
      }
    }
    else
    {
      localColor = q();
    }
    if (localColor != null)
    {
      Stroke localStroke = paramGraphics2D.getStroke();
      paramGraphics2D.setStroke(r());
      if (!bool2)
      {
        paramGraphics2D.setColor(localColor);
        if (i == 2)
        {
          pc localpc = (pc)paramGraphics2D.getRenderingHint(kg.z);
          Object localObject = paramGraphics2D.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
          if (!bool2)
          {
            if (!RenderingHints.VALUE_ANTIALIAS_ON.equals(localObject)) {
              if ((bool2) || (localpc != null))
              {
                if (bool2) {
                  break label206;
                }
                if (localpc.c()) {}
              }
              else
              {
                paramGraphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                paramGraphics2D.draw(this.R);
                if (bool2) {
                  break label218;
                }
                paramGraphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, localObject);
                if (!bool1) {
                  break label217;
                }
              }
            }
            if (bool2) {
              break label218;
            }
            paramGraphics2D.draw(this.R);
          }
          label206:
          if (!bool1) {
            break label217;
          }
        }
      }
      paramGraphics2D.draw(this.R);
      label217:
      label218:
      paramGraphics2D.setStroke(localStroke);
    }
  }
  
  protected void i(Graphics2D paramGraphics2D)
  {
    boolean bool2 = ld.E;
    Color localColor1 = o();
    if ((localColor1 != null) && ((bool2) || (!s())))
    {
      boolean bool1 = a(this, paramGraphics2D);
      Color localColor2 = p();
      if (localColor2 != null)
      {
        if (bool2) {
          break label139;
        }
        if (kg.c(paramGraphics2D))
        {
          if (!bool2)
          {
            if (bool1)
            {
              localColor2 = g(localColor2);
              localColor1 = g(localColor1);
            }
            if (bool2) {
              break label156;
            }
            paramGraphics2D.setPaint(new GradientPaint((float)(this.y + this.A / 3.0D), (float)this.z, localColor1, (float)(this.y + this.A), (float)this.z, localColor2, true));
          }
          if (!ld.D) {
            break label155;
          }
        }
      }
      label139:
      paramGraphics2D.setColor(bool1 ? g(localColor1) : localColor1);
      label155:
      label156:
      paramGraphics2D.fill(this.R);
    }
  }
  
  protected Color g(Color paramColor)
  {
    return new Color(Math.max((int)(paramColor.getRed() * 0.7D), 0), Math.max((int)(paramColor.getGreen() * 0.7D), 0), Math.max((int)(paramColor.getBlue() * 0.7D), 0), paramColor.getAlpha());
  }
  
  protected void b(Graphics2D paramGraphics2D, boolean paramBoolean)
  {
    boolean bool = ld.E;
    Paint localPaint = paramGraphics2D.getPaint();
    Color localColor1 = paramGraphics2D.getColor();
    Color localColor2 = localColor1.brighter();
    Color localColor3 = localColor1.darker();
    if (!bool)
    {
      if (!paramBoolean)
      {
        if (bool) {
          break label69;
        }
        paramGraphics2D.setColor(localColor3);
      }
    }
    else {
      if (!ld.D) {
        break label68;
      }
    }
    if (localPaint != localColor1) {
      paramGraphics2D.setColor(localColor1);
    }
    label68:
    label69:
    paramGraphics2D.setColor(paramBoolean ? localColor2 : localColor3);
    Rectangle2D.Double localDouble = hb.a().k;
    localDouble.setFrame(this.y, this.z, 1.0D, this.B);
    paramGraphics2D.fill(localDouble);
    localDouble.setFrame(this.y + 1.0D, this.z, this.A - 2.0D, 1.0D);
    paramGraphics2D.fill(localDouble);
    paramGraphics2D.setColor(paramBoolean ? localColor3 : localColor2);
    localDouble.setFrame(this.y + 1.0D, this.z + this.B - 1.0D, this.A - 1.0D, 1.0D);
    paramGraphics2D.fill(localDouble);
    localDouble.setFrame(this.y + this.A - 1.0D, this.z, 1.0D, this.B - 1.0D);
    paramGraphics2D.fill(localDouble);
    paramGraphics2D.setPaint(localPaint);
  }
  
  protected void j(Graphics2D paramGraphics2D)
  {
    boolean bool = ld.E;
    if (((!bool) && (this.Y == null)) || ((bool) || ((this.W == 0) && (this.X == 0)))) {
      return;
    }
    Color localColor = paramGraphics2D.getColor();
    AffineTransform localAffineTransform = paramGraphics2D.getTransform();
    paramGraphics2D.setColor(this.Y);
    paramGraphics2D.translate(this.W, this.X);
    paramGraphics2D.fill(this.R);
    paramGraphics2D.setColor(localColor);
    paramGraphics2D.setTransform(localAffineTransform);
  }
  
  public boolean f(double paramDouble1, double paramDouble2)
  {
    boolean bool = ld.E;
    if (!bool) {
      if (s())
      {
        Rectangle2D.Double localDouble = hb.a().k;
        localDouble.setRect(paramDouble1 - 5.0D, paramDouble2 - 5.0D, 10.0D, 10.0D);
        if ((bool) || (this.R.intersects(localDouble))) {
          if (!bool) {
            if (this.R.contains(paramDouble1 - 5.0D, paramDouble2 - 5.0D))
            {
              if (bool) {
                break label174;
              }
              if (this.R.contains(paramDouble1 + 5.0D, paramDouble2 - 5.0D))
              {
                if (bool) {
                  break label174;
                }
                if (this.R.contains(paramDouble1 - 5.0D, paramDouble2 + 5.0D)) {
                  if (bool) {
                    break label174;
                  }
                }
              }
            }
          }
        }
        label174:
        return !this.R.contains(paramDouble1 + 5.0D, paramDouble2 + 5.0D);
      }
    }
    return this.R.contains(paramDouble1, paramDouble2);
  }
  
  public boolean b(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, Point2D paramPoint2D)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (!bool2) {
      if (paramDouble1 == paramDouble3)
      {
        if (bool2) {
          break label42;
        }
        if (paramDouble2 == paramDouble4) {
          return false;
        }
      }
    }
    label42:
    if (!bool2) {
      if (f(paramDouble1, paramDouble2))
      {
        if (bool2) {
          break label72;
        }
        if (!f(paramDouble3, paramDouble4)) {
          break label68;
        }
      }
    }
    return false;
    label68:
    label72:
    if (!bool2) {
      if (this.S == 2)
      {
        if (bool2) {
          break label278;
        }
        if (paramDouble1 == A())
        {
          if (bool2) {
            break label278;
          }
          if (paramDouble2 == B())
          {
            double d1 = paramDouble3 - A();
            double d2 = paramDouble4 - B();
            if (!bool2) {
              if (this.A >= 1.0E-006D)
              {
                if (bool2) {
                  break label183;
                }
                if (this.B >= 1.0E-006D) {
                  break label175;
                }
              }
            }
            double d3 = 0.0D;
            double d4 = 0.0D;
            if (!bool2)
            {
              if (bool1)
              {
                double d5 = this.A / this.B;
                double d6 = 1.0D / Math.sqrt(d1 * d1 + d2 * d2 * d5 * d5);
                d3 = d1 * (this.A * 0.5D) * d6;
                d4 = d5 * d2 * (this.B * 0.5D) * d6;
              }
              paramPoint2D.setLocation(A() + d3, B() + d4);
            }
            if (bool2) {
              break label359;
            }
            if (!bool1) {
              break label358;
            }
          }
        }
      }
    }
    label175:
    label183:
    if (!bool2) {
      if (this.S == 0)
      {
        if (bool2) {
          break label357;
        }
        if (paramDouble1 == A())
        {
          if (bool2) {
            break label357;
          }
          if (paramDouble2 == B())
          {
            if (!bool2) {
              if (f(paramDouble3, paramDouble4)) {
                return false;
              }
            }
            return a(paramDouble1, paramDouble2, paramDouble3, paramDouble4, paramPoint2D);
          }
        }
      }
    }
    label278:
    label357:
    super.b(paramDouble1, paramDouble2, paramDouble3, paramDouble4, paramPoint2D);
    label358:
    label359:
    return true;
  }
  
  public void b(Rectangle2D paramRectangle2D)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    super.b(paramRectangle2D);
    if (((bool2) || ((this.W != 0) || ((bool2) || (this.X != 0)))) && ((bool2) || (this.Y != null)))
    {
      if (!bool2) {
        if (this.W > 0)
        {
          if (!bool2) {
            if (this.X > 0)
            {
              paramRectangle2D.add(this.y + this.A + this.W, this.z + this.B + this.X);
              if (!bool2) {
                if (!bool1) {
                  return;
                }
              }
            }
            else
            {
              paramRectangle2D.add(this.y + this.A + this.W, this.z + this.X);
            }
          }
          if ((!bool2) && (!bool1)) {
            return;
          }
        }
      }
      if (!bool2)
      {
        if (this.X > 0)
        {
          if (bool2) {
            break label216;
          }
          paramRectangle2D.add(this.y + this.W, this.z + this.B + this.X);
        }
      }
      else if (!bool1) {
        return;
      }
      label216:
      paramRectangle2D.add(this.y + this.W, this.z + this.X);
    }
  }
  
  public void b(Graphics2D paramGraphics2D)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (!bool2) {
      if (this.W == 0)
      {
        if (bool2) {
          break label236;
        }
        if (this.X == 0) {
          break label235;
        }
      }
    }
    if (!bool2) {
      if (this.Y != null)
      {
        double d1 = this.A;
        double d2 = this.B;
        double d3 = this.y;
        double d4 = this.z;
        if (!bool2)
        {
          if (this.W >= 0)
          {
            this.A += this.W;
            if (bool2) {
              break label142;
            }
            if (!bool1) {}
          }
          else
          {
            this.A -= this.W;
          }
        }
        else {
          this.y += this.W;
        }
        if (!bool2)
        {
          if (this.X >= 0)
          {
            label142:
            this.B += this.X;
            if (bool2) {
              break label232;
            }
            if (!bool1) {}
          }
          else
          {
            this.z += this.X;
          }
        }
        else {
          this.B -= this.X;
        }
        super.b(paramGraphics2D);
        this.A = d1;
        this.B = d2;
        this.y = d3;
        if (bool2) {
          break label236;
        }
        this.z = d4;
        if (!bool1) {
          label232:
          return;
        }
      }
    }
    label235:
    label236:
    super.b(paramGraphics2D);
  }
  
  public byte e(double paramDouble1, double paramDouble2)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (!bool2) {
      if (this.W == 0)
      {
        if (bool2) {
          break label239;
        }
        if (this.X == 0) {
          break label233;
        }
      }
    }
    if (!bool2) {
      if (this.Y != null)
      {
        double d1 = this.A;
        double d2 = this.B;
        double d3 = this.y;
        double d4 = this.z;
        if (!bool2)
        {
          if (this.W >= 0)
          {
            this.A += this.W;
            if (bool2) {
              break label143;
            }
            if (!bool1) {}
          }
          else
          {
            this.A -= this.W;
          }
        }
        else {
          this.y += this.W;
        }
        if (!bool2)
        {
          if (this.X >= 0)
          {
            label143:
            this.B += this.X;
            if (bool2) {
              break label204;
            }
            if (!bool1) {}
          }
          else
          {
            this.z += this.X;
          }
        }
        else {
          this.B -= this.X;
        }
        label204:
        b = super.e(paramDouble1, paramDouble2);
        this.A = d1;
        this.B = d2;
        this.y = d3;
        this.z = d4;
        return b;
      }
    }
    label233:
    label239:
    byte b = super.e(paramDouble1, paramDouble2);
    return b;
  }
  
  public void a(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.writeByte(1);
    super.a(paramObjectOutputStream);
    paramObjectOutputStream.writeByte(this.S);
    paramObjectOutputStream.writeByte(this.W);
    paramObjectOutputStream.writeByte(this.X);
    paramObjectOutputStream.writeObject(this.Y);
  }
  
  public void a(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (!bool2) {}
    switch (paramObjectInputStream.readByte())
    {
    case 0: 
      super.a(paramObjectInputStream);
      b(paramObjectInputStream.readByte());
      if (!bool2) {
        if (!bool1) {
          return;
        }
      }
    case 1: 
      super.a(paramObjectInputStream);
      b(paramObjectInputStream.readByte());
      this.W = paramObjectInputStream.readByte();
      this.X = paramObjectInputStream.readByte();
      this.Y = ((Color)paramObjectInputStream.readObject());
      if (!bool1) {
        return;
      }
      break;
    }
    throw new c();
  }
  
  public static Map Z()
  {
    HashMap localHashMap = new HashMap(23);
    localHashMap.put(new Byte((byte)0), "Rectangle");
    localHashMap.put(new Byte((byte)1), "Round Rect");
    localHashMap.put(new Byte((byte)2), "Ellipse");
    localHashMap.put(new Byte((byte)3), "Parallelogram");
    localHashMap.put(new Byte((byte)4), "Hexagon");
    localHashMap.put(new Byte((byte)5), "Triangle");
    localHashMap.put(new Byte((byte)6), "Rectangle 3D");
    localHashMap.put(new Byte((byte)7), "Octagon");
    localHashMap.put(new Byte((byte)8), "Diamond");
    localHashMap.put(new Byte((byte)9), "Trapezoid");
    localHashMap.put(new Byte((byte)10), "Trapezoid 2");
    return localHashMap;
  }
  
  private static final class b_
    extends RenderingHints.Key
  {
    b_()
    {
      super();
    }
    
    public boolean isCompatibleValue(Object paramObject)
    {
      boolean bool = ld.E;
      if ((bool) || (paramObject != null)) {
        if (bool) {
          break label24;
        }
      }
      label24:
      return (paramObject instanceof od.a_);
    }
    
    public String toString()
    {
      return "Sloppy rect painting enable key";
    }
  }
  
  private static final class a_
  {
    public String toString()
    {
      return "sloppy rect painting off";
    }
  }
}



/* Location:           E:\idea\

 * Qualified Name:     a.j.od

 * JD-Core Version:    0.7.0.1

 */